home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / mxcode / ariainit / ariainit.c < prev    next >
C/C++ Source or Header  |  1994-12-15  |  9KB  |  237 lines
  1. /*   ARIAINIT.C    --   C Program to initialize the ARIA sound card.
  2.                         Just like the original, this program is very
  3.                         picky about the format of the config file.
  4.  
  5.      This program may be compiled with Microsoft Quick-C (2.?) or MSVC++
  6.  
  7.      11/4/94  Initial Creation
  8.     11/10/94  1.00 Released
  9.     12/15/94  Removed copyright
  10. */
  11.  
  12. #include <stdio.h>
  13. #include <string.h>
  14.  
  15. void      initConfig (int label, int index);
  16. void      writeConfig(unsigned aReg, unsigned value);
  17. unsigned  readBack(unsigned rba);
  18.  
  19. /*
  20.    These are the config labels in the Aria config file:
  21. */
  22. char aBas[]= "ARIA_BASE";
  23. char aIrq[]= "ARIA_IRQ";
  24. char aDma[]= "ARIA_DMA";
  25. char bBas[]= "SB_BASE";
  26. char bIrq[]= "SB_IRQ";
  27. char bDma[]= "SB_DMA";
  28. char mBas[]= "MIDI_BASE";
  29. char mIrq[]= "MIDI_IRQ";
  30. char sBas[]= "SCSI_BASE";
  31. char sIrq[]= "SCSI_IRQ";
  32. char lBas[]= "ADLIB_BASE";
  33. char jBas[]= "JOYSTICK_BASE";
  34. char jSpd[]= "JOYSTICK_SPEED";
  35. char rSiz[]= "ROM_SIZE";
  36.  
  37. char *cfgLabl[]= { aBas, aIrq, aDma, bBas, bIrq, bDma, mBas,
  38.                    mIrq, sBas, sIrq, lBas, jBas, jSpd, rSiz };
  39.  
  40. int labelCnt= (sizeof(cfgLabl) / sizeof(cfgLabl[0]) );
  41.  
  42. /*
  43.    These are the config values for each label in the Aria config file:
  44. */
  45. char *aBv[]= { "290",    "280",   "2A0",   "2B0",    "NONE",   NULL };
  46. char *aIv[]= { "10",     "11",    "12",    "NONE",    NULL };
  47. char *aDv[]= { "5",      "6",     "NONE",   NULL };
  48. char *bBv[]= { "220",    "240",   "NONE",   NULL };
  49. char *bIv[]= { "7",      "5",     "9",     "2",      "NONE",   NULL };
  50. char *bDv[]= { "1",      "0",     "NONE",   NULL };
  51. char *mBv[]= { "330",    "320",   "NONE",   NULL };
  52. char *mIv[]= { "9",      "2",     "5",     "7",      "NONE",   NULL };
  53. char *sBv[]= { "CA000",  "C8000", "CE000", "DE000",  "NONE",   NULL };
  54. char *sIv[]= { "NONE",   "11",    "10",    "12",      NULL };
  55. char *lBv[]= { "388",    "NONE",  NULL };
  56. char *jBv[]= { "200",    "NONE",  NULL };
  57. char *jSv[]= { "NORMAL", "FAST",  NULL };
  58. char *rSv[]= { "512",    "1024",  NULL };
  59.  
  60. char * *cfgValu[]= { aBv, aIv, aDv, bBv, bIv, bDv, mBv, mIv,
  61.                      sBv, sIv, lBv, jBv, jSv, rSv };
  62. /*
  63.    These are bit constants that corespond to labels in the config file.
  64. */
  65. unsigned char aBb[]= { 0xA4, 0xA0, 0xA8, 0xAC, 0x00 };
  66. unsigned char aIb[]= { 0x04, 0x05, 0x06, 0x00  };
  67. unsigned char aDb[]= {    0,    0,    0  };
  68. unsigned char bBb[]= { 0x88, 0x90, 0x00  };
  69. unsigned char bIb[]= { 0x03, 0x02, 0x01, 0x01, 0x00 };
  70. unsigned char bDb[]= {    0,    0,    0  };
  71. unsigned char mBb[]= { 0xCC, 0xC8, 0x00  };
  72. unsigned char mIb[]= { 0x01, 0x01, 0x02, 0x03, 0x00 };
  73. unsigned char sBb[]= { 0x34, 0x24, 0x14, 0x04, 0x00 };
  74. unsigned char sIb[]= { 0x00, 0x05, 0x04, 0x06  };
  75. unsigned char lBb[]= { 0xE2, 0x00  };
  76. unsigned char jBb[]= { 0x80, 0x00  };
  77. unsigned char jSb[]= {    0,    0  };
  78. unsigned char rSb[]= {    0,    0  };
  79.  
  80. unsigned char *cfgBits[]= { aBb, aIb, aDb, bBb, bIb, bDb, mBb, mIb,
  81.                             sBb, sIb, lBb, jBb, jSb, rSb };
  82. /*
  83.    These are and/or mask constants coresponding to labels in the config file:
  84. */
  85. unsigned char aBm[]= { 0xBF,0xA0, 0xBF,0xA0, 0xBF,0xA0, 0xBF,0xA0, 0x88,0x00 };
  86. unsigned char aIm[]= { 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xF8,0x00  };
  87. unsigned char aDm[]= { 0xF7,0x10, 0xFF,0x18, 0xEF,0x00  };
  88. unsigned char bBm[]= { 0xDF,0xC0, 0xDF,0xC0, 0x88,0x00  };
  89. unsigned char bIm[]= { 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xF8,0x00 };
  90. unsigned char bDm[]= { 0xFF,0x18, 0xF7,0x10, 0xEF,0x00  };
  91. unsigned char mBm[]= { 0x3F,0x20, 0x3F,0x20, 0x88,0x00  };
  92. unsigned char mIm[]= { 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xFF,0x00 };
  93. unsigned char sBm[]= { 0xCF,0x00, 0xCF,0x00, 0xCF,0x00, 0xFB,0x00  };
  94. unsigned char sIm[]= { 0xF8,0x00, 0xF8,0x00, 0xF8,0x00, 0xF8,0x00  };
  95. unsigned char lBm[]= { 0xBF,0xA0, 0x9F,0x00  };
  96. unsigned char jBm[]= { 0x3F,0x20, 0x9F,0x00  };
  97. unsigned char jSm[]= { 0xFF,0x08, 0xF7,0x00  };
  98. unsigned char rSm[]= { 0xBF,0x00, 0xFF,0x40  };
  99.  
  100. unsigned char *cfgMask[]= { aBm, aIm, aDm, bBm, bIm, bDm, mBm, mIm,
  101.                             sBm, sIm, lBm, jBm, jSm, rSm };
  102.  
  103. int cfgFunc[]= { 0x111, 0x11, 0x11, 0x113, 0x13, 0x13, 0x117,
  104.                  0x17, 0x0E, 0x19, 0x115, 0x19, 0x0E, 0x0E };
  105.  
  106. #define bufSize  32
  107.  
  108. unsigned char buf1[bufSize];
  109. unsigned rba= 0x300;
  110.  
  111. void main(argc, argv)
  112. int argc;
  113. char *argv[];
  114. {
  115. FILE *fp1;
  116. unsigned end;
  117. char *filVal, **ptr;
  118. int err, label, index;
  119.  
  120.  printf("\n  *** Aria port configuration program ***");
  121.  printf("\nVersion 1.00, Thomas K. Myers 1994\n");
  122.  err= 0;
  123.  if (argc >= 2) {                                     /* Validate cmd parms */
  124.     if ((fp1= fopen(argv[1], "rt")) == (FILE *)0) {
  125.        printf("\nERROR: Opening ARIA config file!");
  126.        err= 1;
  127.        }
  128.     if (argc == 3) {                                /* Process optional rba */
  129.        sscanf(argv[2], "%X", &rba);
  130.        if ((rba < 0x280) || (rba > 0x330)) {
  131.           printf("\nERROR: Invalid Read Back Address!");
  132.           err=2;
  133.           }
  134.        else printf("\nUsing rba= %X", rba);
  135.        }
  136.     outp(0x204, 0x4C);                             /* Begin config sequence */
  137.     outp(0x205, 0x42);
  138.     outp(0x206, 0x00);
  139.     writeConfig(0x000F, 0x00);
  140.     writeConfig(0x0002, rba >> 2);
  141.     /*
  142.       For each line of the file,  figure out which label it is,
  143.       and the index of it's parameter value.  Thus the ordering
  144.       of say,  ARIA_BASE and ROM_SIZE  may be rearranged in the
  145.       file and still send the same info to the  Aria ports,  it
  146.       may well be that the sequence is also important. I do not
  147.       know if it is or not. 11/6/94
  148.     */
  149.     while (! err && fgets(buf1, sizeof(buf1) - 2, fp1)) {
  150.        for (label= 0; (label < labelCnt) &&                       /* label? */
  151.                       ! strstr(buf1, cfgLabl[ label ]); label++);
  152.        if (label > labelCnt) {
  153.           printf("\nERROR: Illegal parameter specified!");
  154.           err= 3;
  155.           }
  156.        else {
  157.           buf1[ strlen(buf1) - 1 ] = '\0';          /* Find parameter index */
  158.           filVal= strchr(buf1, '=') + 1;
  159.           ptr= cfgValu[ label ];
  160.           for (index= 0; ptr[ index ] &&
  161.                          strcmpi(filVal, ptr[ index ]); index++);
  162.           if (ptr[ index ] == NULL) {
  163.              printf("\nERROR: Invalid parameter value!");
  164.              err= 4;
  165.              }
  166.           initConfig(label, index);                   /* Do some port magic */
  167.           }
  168.        }
  169.     fclose(fp1);
  170.     end= readBack(0x000F);                           /* End config sequence */
  171.     writeConfig(0x000F, end | 0x80);
  172.     if (! err) printf("\n\nAria board configured.");
  173.     inp(0x200);
  174.     }
  175.   else printf("\nUSAGE: ARIAinit <cfgFile> [readBack port, 280H - 330H ]");
  176. }
  177.  
  178. /*
  179.   This is where things happen. It is all table driven, so the purpose of
  180.   the values is not known. My guess is that the "func" value is the Aria
  181.   chip's register that establishes a functional port configuration. Thus
  182.   there may be a corespondence between func=15 and ADLIB_BASE.  The pur-
  183.   pose of the rba is also unclear. Since the Aria offers a wide range of
  184.   port config options which could be conflicting,  perhaps the rba value
  185.   is used to prohibit/correct conflicting settings.  I can see a corela-
  186.   tion of how the base port address for ARIA, SB, MIDI and ADLIB are set
  187.   vs. the other parameters. The base is set using the code within the IF
  188.   block, while the other parameters are set using the ELSE code.
  189. */
  190. void initConfig (label, index)
  191. int label, index;
  192. {
  193. unsigned char *ptr;
  194. unsigned int  and, or, bits, func, rbaIn;
  195.  
  196.  func= cfgFunc[ label ];                          /* Get values from tables */
  197.  
  198.  ptr= cfgBits[ label ];
  199.  bits= ptr[ index ];
  200.  
  201.  ptr= cfgMask[ label ];
  202.  and= ptr[ index * 2 ];
  203.  or= ptr[ (index * 2) + 1 ];
  204.  
  205.  if (func & 0x100) {                         /* "BASE" functions output the */
  206.     func &= ~0x100;                         /* bits first, then do the rba. */
  207.     if (bits) writeConfig(func - 1, bits);     /* And, bits go out func - 1 */
  208.     }
  209.  else or |= bits;                            /* The others do the rba thing */
  210.                                          /* first, then add the bits to it. */
  211.  rbaIn= readBack(func);
  212.  writeConfig(func, (rbaIn & and) | or);
  213.  
  214.  printf("\n%14.14s: Index=%d func=%0.4X Bits=%0.2X rbaIn=%0.2X and=%0.2X Or=%0.2X",
  215.     cfgLabl[ label ], index,      func,      bits,      rbaIn,      and,       or);
  216. }
  217.  
  218. /*
  219.   Function to write config port values to config port addresses
  220. */
  221. void writeConfig(aReg, value)
  222. unsigned aReg, value;
  223. {
  224.  outpw(0x200, aReg);
  225.  outp(0x201, value);
  226. }
  227.  
  228. /*
  229.   Function to read back config port values
  230. */
  231. unsigned readBack(aReg)
  232. unsigned aReg;
  233. {
  234.  outp(0x200, aReg);
  235.  return inp(rba);
  236. }
  237.